home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / unix / volume13 / pas2c.pch < prev    next >
Encoding:
Internet Message Format  |  1988-01-31  |  35.8 KB
  1. Subject:  v13i067:  Patches for Pascal-to-C translator
  2. Newsgroups: comp.sources.unix
  3. Sender: sources
  4. Approved: rsalz@uunet.UU.NET
  5.  
  6. Submitted-by: Per Bergsten <mcvax!enea!chalmers!holtec!perb>
  7. Posting-number: Volume 13, Issue 67
  8. Archive-name: pas2c.pch
  9.  
  10. The following diffs adress all errors in the Pascal-to-C-translator that have
  11. been reported to me. The translator was posted during summer -87 and a few
  12. bug-reports came in during August. I have had no reports since late September
  13. which I take to mean that either nobody has found any use for the program or
  14. that there are no remaining serious problems.
  15.  
  16. Happily, with one exception, no report concerned cases where the translator
  17. silently produced wrong code. There were some cases where the translator would
  18. fail or where it generated code that was syntactically incorrect.
  19. The exception concerned the status of "input" before the program had tested
  20. "eof". This was actually a "feature" since the behaviour was intended (though
  21. not formally correct).
  22.  
  23. Comments, questions etc to:
  24.  
  25.     Per Bergsten
  26.  
  27.             perb@holtec.se    (....mcvax!enea!chalmers!holtec!perb)
  28.             perb%holtec.uucp@chalmers.csnet
  29.  
  30. -------------------------------------------------------------------------------
  31. #! /bin/sh
  32. # This is a shell archive, meaning:
  33. # 1. Remove everything above the #! /bin/sh line.
  34. # 2. Save the resulting text in a file.
  35. # 3. Execute the file with /bin/sh (not csh) to create the files:
  36. #    READ_ME
  37. #    ptc.diff
  38. export PATH; PATH=/bin:$PATH
  39. if test -f 'READ_ME'
  40. then
  41.     echo shar: will not over-write existing file "'READ_ME'"
  42. else
  43. cat << \SHAR_EOF > 'READ_ME'
  44. The following problems have been adressed.
  45.  
  46.     1)    In some circumstances the reader misread 1..n which lead to
  47.         a complaint about malplaced floating point numbers.
  48.  
  49.     2)    The translator generated double "->" arrows for references to
  50.         VAR-parameters that were pointers.
  51.  
  52.     3)    Missing initialisation of pointers in a record variant for
  53.         case-statements sometimes caused the translator to crash.
  54.  
  55.     4)    Calling "write" with a boolean literal as parameter caused the
  56.         translator to crash.
  57.  
  58.     5)    Initialization of input. Programs that read input before
  59.         testing for eof can be made to work by defining a compiletime
  60.         constant STDINIT otherwise the first returned character will
  61.         be null.
  62.  
  63.     6)    The code generated for procedurecalls with string-literal
  64.         parameters could cause the resulting program to crash due to
  65.         alignment errors. This is truly a PATCH, i.e. the "correct"
  66.         solution would require a redesign of the translator.
  67.  
  68.         In this case the problem has been swept under the carpet at
  69.         the cost of some runtime overhead by copying data.
  70.         The behaviour of the translator is controlled by a boolean
  71.         constant "align" which, if true, cuses the translator to
  72.         generate calls to to functions STRALIGN and SETALIGN.
  73.         STRALIGN and SETALIGN are macros which by default call simple
  74.         subroutines that will copy data to well aligned structures.
  75.  
  76.     7)    Types and variables in nested procedures were not always moved
  77.         to an enclosing scope when the procedures were un-nested.
  78.  
  79.     8)    The I/O macros were modified so that "rewind" was replaced by
  80.         "fseek" and so that the generated code is type-correct.
  81.  
  82.     9)    The translator didn't handle incomplete Pascal programs as
  83.         documented.
  84.  
  85.     10)    A few changes were made to remove illegal Pascal-code.
  86. SHAR_EOF
  87. fi # end of overwriting check
  88. if test -f 'ptc.diff'
  89. then
  90.     echo shar: will not over-write existing file "'ptc.diff'"
  91. else
  92. cat << \SHAR_EOF > 'ptc.diff'
  93. *** ptc.p    Fri Nov 13 18:45:21 1987
  94. --- nptc.p    Fri Nov 13 18:44:29 1987
  95. ***************
  96. *** 42,48 ****
  97.   (**    The code generated by the translator assumes that there    is a      **)
  98.   (**    C-implementation with at least a reasonable <stdio> library      **)
  99.   (**    since all input/output is implemented in terms of C functions      **)
  100. ! (**    like fprintf(), getc(), fopen(), rewind() etc.              **)
  101.   (**    If the source-program uses Pascal functions like sin(), sqrt()      **)
  102.   (**    etc, there must also exist such functions in the C-library.      **)
  103.   (**                                      **)
  104. --- 42,48 ----
  105.   (**    The code generated by the translator assumes that there    is a      **)
  106.   (**    C-implementation with at least a reasonable <stdio> library      **)
  107.   (**    since all input/output is implemented in terms of C functions      **)
  108. ! (**    like fprintf(), getc(), fopen(), fseek() etc.              **)
  109.   (**    If the source-program uses Pascal functions like sin(), sqrt()      **)
  110.   (**    etc, there must also exist such functions in the C-library.      **)
  111.   (**                                      **)
  112. ***************
  113. *** 53,59 ****
  114.   
  115.   label    9999;                (* end of program        *)
  116.   
  117. ! const    version        = '@(#)ptc.p    1.5  Date 87/05/01';
  118.   
  119.       keytablen    = 38;        (* nr of keywords        *)
  120.       keywordlen    = 10;        (* length of a keyword        *)
  121. --- 53,59 ----
  122.   
  123.   label    9999;                (* end of program        *)
  124.   
  125. ! const    version        = '@(#)ptc.p    2.6  Date 87/09/12';
  126.   
  127.       keytablen    = 38;        (* nr of keywords        *)
  128.       keywordlen    = 10;        (* length of a keyword        *)
  129. ***************
  130. *** 67,75 ****
  131.       setbits        = 15;            (* CPU *)
  132.   
  133.       (* a Pascal file is implemented as a struct which (among other    *)
  134. !     (* things) contain a flag-field, currently 3 bits are used    *)
  135.       filebits    = 'unsigned short';    (* flags for files    *)
  136. !     filefill    = 12;            (* 16 less used 3 bits    *)
  137.   
  138.       maxsetrange    = 15;            (* nr of words in a set    *)
  139.       scalbase    = 0;    (* ordinal value of first scalar member    *)
  140. --- 67,75 ----
  141.       setbits        = 15;            (* CPU *)
  142.   
  143.       (* a Pascal file is implemented as a struct which (among other    *)
  144. !     (* things) contain a flag-field, currently 4 bits are used    *)
  145.       filebits    = 'unsigned short';    (* flags for files    *)
  146. !     filefill    = 12;            (* 16 less used 4 bits    *)
  147.   
  148.       maxsetrange    = 15;            (* nr of words in a set    *)
  149.       scalbase    = 0;    (* ordinal value of first scalar member    *)
  150. ***************
  151. *** 106,111 ****
  152. --- 106,112 ----
  153.          temporary files for reset/rewrite, the last character is supplied
  154.          by the reset/rewrite routine *)
  155.       tmpfilename    = '"/tmp/ptc%d%c", getpid(), '; (* OS *)
  156. +     maxfilename    = 'MAXFILENAME';
  157.   
  158.       (* some frequently used characters *)
  159.       space        = ' ';
  160. ***************
  161. *** 146,151 ****
  162. --- 147,154 ----
  163.       voidtyp        = 'void';    (* for procedures         *)
  164.       voidcast    = '(void)';
  165.   
  166. +     align        = true;        (* align literal params        *)
  167. + 
  168.       intlen        = 10;        (* length of written integer    *)
  169.       fixlen        = 20;        (* length of written real    *)
  170.   
  171. ***************
  172. *** 239,244 ****
  173. --- 242,264 ----
  174.             sinteger:    (vint    : integer);
  175.             sreal:    (vflt    : strindx);
  176.             sstring:    (vstr    : strindx);
  177. + 
  178. +           sand,        sarray,        sbegin,        scase,
  179. +           sconst,    sdiv,        sdo,        sdownto,
  180. +           selse,    send,        sextern,    sfile,
  181. +           sfor,        sforward,    sfunc,        sgoto,
  182. +           sif,        sinn,        slabel,        smod,
  183. +           snil,        snot,        sof,        sor,
  184. +           sother,    spacked,    sproc,        spgm,
  185. +           srecord,    srepeat,    sset,        sthen,
  186. +           sto,        stype,        suntil,        svar,
  187. +           swhile,    swith,        seof,
  188. +           splus,    sminus,        smul,        squot,
  189. +           sarrow,    slpar,        srpar,        slbrack,
  190. +           srbrack,    seq,        sne,        slt,
  191. +           sle,        sgt,        sge,        scomma,
  192. +           scolon,    ssemic,        sassign,    sdotdot,
  193. +           sdot:        ()
  194.           end;
  195.   
  196.       (* enumeration of symnode variants *)
  197. ***************
  198. *** 648,653 ****
  199. --- 668,674 ----
  200.           cstdout,    cstderr,    cstrncmp,    cstrncpy,
  201.           cstruct,    cstatic,    cswitch,    ctypedef,
  202.           cundef,        cungetc,    cunion,        cunlink,
  203. +         cfseek,        cgetchar,    cputchar,
  204.           cunsigned,    cwrite
  205.       );
  206.   
  207. ***************
  208. *** 661,667 ****
  209.           enew,        esetbase,    esetsize,    eoverflow,
  210.           etree,        etag,        euprconf,    easgnconf,
  211.           ecmpconf,    econfconf,    evrntfile,    evarfile,
  212. !         emanymachs,    ebadmach
  213.       );
  214.   
  215.       machdefstr = packed array [ 1 .. machdeflen ] of char;
  216. --- 682,688 ----
  217.           enew,        esetbase,    esetsize,    eoverflow,
  218.           etree,        etag,        euprconf,    easgnconf,
  219.           ecmpconf,    econfconf,    evrntfile,    evarfile,
  220. !         emanymachs,    ebadmach,    eprconf
  221.       );
  222.   
  223.       machdefstr = packed array [ 1 .. machdeflen ] of char;
  224. ***************
  225. *** 683,688 ****
  226. --- 704,711 ----
  227.       useins,
  228.       usescpy,
  229.       usecomp,        (* source program uses string-compare    *)
  230. +     usealig,        (* source program uses aligned params    *)
  231. +     usesal,
  232.       usefopn,        (* source program uses reset/rewrite    *)
  233.       usescan,
  234.       usegetl,
  235. ***************
  236. *** 738,745 ****
  237.   
  238.       varno    : integer;        (* counter for unique id's    *)
  239.   
  240. !     hexdig    : packed array [ 0 .. 15 ] of char;
  241.   
  242.   (*    Prtmsg produces an error message. It asssumes that procedure    *)
  243.   (*    "message" (predefined) will "writeln" to user tty. OS        *)
  244.   procedure prtmsg(m : errors);
  245. --- 761,771 ----
  246.   
  247.       varno    : integer;        (* counter for unique id's    *)
  248.   
  249. !     pushchr    : char;            (* pushback for lexical scanner    *)
  250. !     pushed    : boolean;
  251.   
  252. +     hexdig    : array [ 0 .. 15 ] of char;
  253. + 
  254.   (*    Prtmsg produces an error message. It asssumes that procedure    *)
  255.   (*    "message" (predefined) will "writeln" to user tty. OS        *)
  256.   procedure prtmsg(m : errors);
  257. ***************
  258. *** 814,819 ****
  259. --- 840,847 ----
  260.           message(restr, 'Too many machine integer types');
  261.         ebadmach:
  262.           message(inter, 'Bad name for machine integer type');
  263. +       eprconf:
  264. +         message(restr, 'Cannot write conformant arrays');
  265.       end;(* case *)
  266.       if lastline <> 0 then
  267.           begin
  268. ***************
  269. *** 1219,1225 ****
  270.       var    c    : char;
  271.   
  272.       begin
  273. !         if eof then
  274.               c := chr(null)
  275.           else begin
  276.               colno := colno + 1;
  277. --- 1247,1258 ----
  278.       var    c    : char;
  279.   
  280.       begin
  281. !         if pushed then
  282. !             begin
  283. !             c := pushchr;
  284. !             pushed := false
  285. !             end
  286. !         else if eof then
  287.               c := chr(null)
  288.           else begin
  289.               colno := colno + 1;
  290. ***************
  291. *** 1235,1241 ****
  292.                   else
  293.                       write(c);
  294.               if c = tab1 then
  295. !                 colno := ((colno div tabwidth) + 1) * tabwidth
  296.                end;
  297.           if lastchr > 0 then
  298.               begin
  299. --- 1268,1275 ----
  300.                   else
  301.                       write(c);
  302.               if c = tab1 then
  303. !                 colno := (((colno - 1) div tabwidth) + 1) *
  304. !                         tabwidth
  305.                end;
  306.           if lastchr > 0 then
  307.               begin
  308. ***************
  309. *** 1249,1255 ****
  310.       function peekchar : char;
  311.   
  312.       begin
  313. !         if eof then
  314.               peekchar := chr(null)
  315.           else
  316.               peekchar := input^
  317. --- 1283,1291 ----
  318.       function peekchar : char;
  319.   
  320.       begin
  321. !         if pushed then
  322. !             peekchar := pushchr
  323. !         else if eof then
  324.               peekchar := chr(null)
  325.           else
  326.               peekchar := input^
  327. ***************
  328. *** 1458,1466 ****
  329.                       end;
  330.                   st := sinteger;
  331.                   vint := n;
  332.                   if realok then
  333.                       begin
  334. -                     (* accept real numbers *)
  335.                       if peekchar = '.' then
  336.                           begin
  337.                           (* this is a real number *)
  338. --- 1494,1508 ----
  339.                       end;
  340.                   st := sinteger;
  341.                   vint := n;
  342. +                 if realok and (peekchar = '.') then
  343. +                     begin
  344. +                     c := nextchar;
  345. +                     realok := numchar(peekchar);
  346. +                     pushchr := c;
  347. +                     pushed := true
  348. +                     end;
  349.                   if realok then
  350.                       begin
  351.                       if peekchar = '.' then
  352.                           begin
  353.                           (* this is a real number *)
  354. ***************
  355. *** 1579,1585 ****
  356.                 quote:
  357.                   begin
  358.                   (* assume the symbol is a literal string *)
  359. !                 wl := 0;
  360.                   ready := false;
  361.                   repeat
  362.                       if eoln then
  363. --- 1621,1627 ----
  364.                 quote:
  365.                   begin
  366.                   (* assume the symbol is a literal string *)
  367. !                 wl := 1;
  368.                   ready := false;
  369.                   repeat
  370.                       if eoln then
  371. ***************
  372. *** 1602,1608 ****
  373.                           end;
  374.                       if not ready then
  375.                           begin
  376. !                         wl := wl + 1;
  377.                           if wl >= maxtoknlen then
  378.                               begin
  379.                               lasttok[lastchr] :=
  380. --- 1644,1650 ----
  381.                           end;
  382.                       if not ready then
  383.                           begin
  384. !                         wb[wl] := c;
  385.                           if wl >= maxtoknlen then
  386.                               begin
  387.                               lasttok[lastchr] :=
  388. ***************
  389. *** 1609,1618 ****
  390.                                   chr(null);
  391.                               error(elongstring)
  392.                               end;
  393. !                         wb[wl] := c
  394.                           end
  395.                   until    ready;
  396. !                 if wl = 1 then
  397.                       begin
  398.                       (* only 1 character => not a string *)
  399.                       st := schar;
  400. --- 1651,1660 ----
  401.                                   chr(null);
  402.                               error(elongstring)
  403.                               end;
  404. !                         wl := wl + 1;
  405.                           end
  406.                   until    ready;
  407. !                 if wl = 2 then
  408.                       begin
  409.                       (* only 1 character => not a string *)
  410.                       st := schar;
  411. ***************
  412. *** 1620,1631 ****
  413.                       end
  414.                   else begin
  415.                       (* > 1 character => its a string *)
  416. -                     wl := wl + 1;
  417. -                     if wl >= maxtoknlen then
  418. -                         begin
  419. -                         lasttok[lastchr] := chr(null);
  420. -                         error(elongstring)
  421. -                         end;
  422.                       wb[wl] := chr(null);
  423.                       st := sstring;
  424.                       vstr := savestr(wb)
  425. --- 1662,1667 ----
  426. ***************
  427. *** 2645,2650 ****
  428. --- 2681,2687 ----
  429.                           sproc, sfunc, sbegin]);
  430.           pbody(tp);
  431.           checksymbol([sdot]);
  432. +         nextsymbol([seof]);
  433.           tp^.tscope := currscope;
  434.           leavescope;
  435.           pprogram := tp
  436. ***************
  437. *** 2662,2668 ****
  438.           tp^.tsubid := nil;
  439.           tp^.tsubpar := nil;
  440.           pbody(tp);
  441. !         checksymbol([ssemic]);
  442.           tp^.tscope := currscope;
  443.           leavescope;
  444.           pmodule := tp
  445. --- 2699,2707 ----
  446.           tp^.tsubid := nil;
  447.           tp^.tsubpar := nil;
  448.           pbody(tp);
  449. !         checksymbol([ssemic, seof]);
  450. !         if currsym.st = ssemic then
  451. !             nextsymbol([seof]);
  452.           tp^.tscope := currscope;
  453.           leavescope;
  454.           pmodule := tp
  455. ***************
  456. *** 2799,2805 ****
  457.               enterscope(dp);
  458.               dp := currscope
  459.               end;
  460. !         nextsymbol([sid, scase] + [cs]);
  461.           tq := nil;
  462.           while currsym.st = sid do
  463.               begin
  464. --- 2838,2844 ----
  465.               enterscope(dp);
  466.               dp := currscope
  467.               end;
  468. !         nextsymbol([sid, scase, cs]);
  469.           tq := nil;
  470.           while currsym.st = sid do
  471.               begin
  472. ***************
  473. *** 2820,2826 ****
  474.               tq^.tbind := ptypedef;
  475.               enterscope(dp);
  476.               if currsym.st = ssemic then
  477. !                 nextsymbol([sid, scase] + [cs])
  478.               end;
  479.           if currsym.st = scase then
  480.               begin
  481. --- 2859,2865 ----
  482.               tq^.tbind := ptypedef;
  483.               enterscope(dp);
  484.               if currsym.st = ssemic then
  485. !                 nextsymbol([sid, scase, cs])
  486.               end;
  487.           if currsym.st = scase then
  488.               begin
  489. ***************
  490. *** 2852,2858 ****
  491.                   tv := nil;
  492.                   repeat
  493.                       nextsymbol([sid, sinteger, schar, splus,
  494. !                              sminus] + [cs]);
  495.                       if currsym.st = cs then
  496.                           goto 999;
  497.                       if tv = nil then
  498. --- 2891,2897 ----
  499.                   tv := nil;
  500.                   repeat
  501.                       nextsymbol([sid, sinteger, schar, splus,
  502. !                              sminus, cs]);
  503.                       if currsym.st = cs then
  504.                           goto 999;
  505.                       if tv = nil then
  506. ***************
  507. *** 3650,3655 ****
  508. --- 3689,3696 ----
  509.                   tq^.tnext := mknode(nchoise);
  510.                   tq := tq^.tnext
  511.                    end;
  512. +             tq^.tchocon := nil;
  513. +             tq^.tchostmt := nil;
  514.               tv := nil;
  515.               repeat
  516.                   nextsymbol([sid, sinteger, schar,
  517. ***************
  518. *** 3845,3852 ****
  519.       if currsym.st = spgm then
  520.           top := pprogram
  521.       else
  522. !         top := pmodule;
  523. !     nextsymbol([seof]);
  524.   end;    (* parse *)
  525.   
  526.   (*    Compute value for a node (which must be some kind of constant).    *)
  527. --- 3886,3892 ----
  528.       if currsym.st = spgm then
  529.           top := pprogram
  530.       else
  531. !         top := pmodule
  532.   end;    (* parse *)
  533.   
  534.   (*    Compute value for a node (which must be some kind of constant).    *)
  535. ***************
  536. *** 4317,4328 ****
  537.                           move := true;
  538.                           sp := ip^.tsym;
  539.                           if sp^.lid^.inref > 1 then
  540. -                           begin
  541.                               sp^.lid :=
  542. !                             mkrename( 'M', sp^.lid);
  543. !                             sp^.lid^.inref :=
  544. !                                 sp^.lid^.inref - 1
  545. !                           end;
  546.                           ip := nil
  547.                           end
  548.                       else
  549. --- 4357,4364 ----
  550.                           move := true;
  551.                           sp := ip^.tsym;
  552.                           if sp^.lid^.inref > 1 then
  553.                               sp^.lid :=
  554. !                             mkrename('M', sp^.lid);
  555.                           ip := nil
  556.                           end
  557.                       else
  558. ***************
  559. *** 4619,4624 ****
  560. --- 4655,4662 ----
  561.   
  562.                   (* mark those used in nested subroutines *)
  563.                   global(tp^.tsubsub, tp, false);
  564. +                 global(tp^.tsubvar, tp, false);
  565. +                 global(tp^.tsubtype, tp, false);
  566.   
  567.                   (* move out variables used in inner scope *)
  568.                   movevars(tp, tp^.tsubpar);
  569. ***************
  570. *** 4887,4896 ****
  571.                      a unique name *)
  572.                   sp := tp^.tsubid^.tsym;
  573.                   if sp^.lid^.inref > 1 then
  574. !                     begin
  575. !                     sp^.lid := mkrename('P', sp^.lid);
  576. !                     sp^.lid^.inref := sp^.lid^.inref - 1
  577. !                     end
  578.                   end;
  579.               tp := tp^.tnext
  580.               end
  581. --- 4925,4931 ----
  582.                      a unique name *)
  583.                   sp := tp^.tsubid^.tsym;
  584.                   if sp^.lid^.inref > 1 then
  585. !                     sp^.lid := mkrename('P', sp^.lid)
  586.                   end;
  587.               tp := tp^.tnext
  588.               end
  589. ***************
  590. *** 5131,5136 ****
  591. --- 5166,5172 ----
  592.   
  593.   const    include    = '# include ';
  594.       define    = '# define ';
  595. +     undef    = '# undef ';
  596.       ifdef    = '# ifdef ';
  597.       ifndef    = '# ifndef ';
  598.       elsif    = '# else';
  599. ***************
  600. *** 5145,5152 ****
  601.   var    conflag,
  602.       setused,
  603.       dropset,
  604. -     donearr    : boolean;
  605.       doarrow,
  606.       indnt    : integer;
  607.   
  608.       procedure increment;
  609. --- 5181,5188 ----
  610.   var    conflag,
  611.       setused,
  612.       dropset,
  613.       doarrow,
  614. +     donearr    : boolean;
  615.       indnt    : integer;
  616.   
  617.       procedure increment;
  618. ***************
  619. *** 5203,5216 ****
  620.       (*    Emit code to select a record member.    *)
  621.       procedure eselect(tp : treeptr);
  622.   
  623.       begin
  624. !         doarrow := doarrow + 1;
  625.           eexpr(tp);
  626. -         doarrow := doarrow - 1;
  627.           if donearr then
  628.               donearr := false
  629.           else
  630. !             write('.')
  631.       end;
  632.   
  633.       (*    Emit code for call to a predefined function/procedure.    *)
  634. --- 5239,5255 ----
  635.       (*    Emit code to select a record member.    *)
  636.       procedure eselect(tp : treeptr);
  637.   
  638. +     var    da    : boolean;
  639. + 
  640.       begin
  641. !         da := doarrow;
  642. !         doarrow := true;
  643.           eexpr(tp);
  644.           if donearr then
  645.               donearr := false
  646.           else
  647. !             write('.');
  648. !         doarrow := da
  649.       end;
  650.   
  651.       (*    Emit code for call to a predefined function/procedure.    *)
  652. ***************
  653. *** 5435,5441 ****
  654.                           else
  655.                               write('*.*');
  656.                       write('s')
  657. !                      end
  658.               end (* case *)
  659.           end;    (* eformat *)
  660.   
  661. --- 5474,5482 ----
  662.                           else
  663.                               write('*.*');
  664.                       write('s')
  665. !                      end;
  666. !               'v':
  667. !                 fatal(eprconf)
  668.               end (* case *)
  669.           end;    (* eformat *)
  670.   
  671. ***************
  672. *** 5572,5578 ****
  673.                       write(', ');
  674.                       eexpr(tq)
  675.                       end
  676. !                 end
  677.               end (* case *)
  678.           end;    (* ewrite *)
  679.   
  680. --- 5613,5621 ----
  681.                       write(', ');
  682.                       eexpr(tq)
  683.                       end
  684. !                 end;
  685. !               'v':
  686. !                 fatal(eprconf)
  687.               end (* case *)
  688.           end;    (* ewrite *)
  689.   
  690. ***************
  691. *** 6212,6218 ****
  692.               write(', ');
  693.               tq := tp^.taparm^.tnext;
  694.               if tq = nil then
  695. !                 write('NULL')
  696.               else begin
  697.                   tq := typeof(tq);
  698.                   if tq = typnods[tchar] then
  699. --- 6255,6261 ----
  700.               write(', ');
  701.               tq := tp^.taparm^.tnext;
  702.               if tq = nil then
  703. !                 write('NULL, 0')
  704.               else begin
  705.                   tq := typeof(tq);
  706.                   if tq = typnods[tchar] then
  707. ***************
  708. *** 6221,6234 ****
  709.                       ch := chr(cvalof(tp^.taparm^.tnext));
  710.                       if (ch = bslash) or (ch = cite) then
  711.                           write(bslash);
  712. !                     write(ch, cite)
  713.                       end
  714.                   else if tq = typnods[tstring] then
  715. !                     eexpr(tp^.taparm^.tnext)
  716. !                 else  if tq^.tt in [narray, nconfarr] then
  717.                        begin
  718.                       eexpr(tp^.taparm^.tnext);
  719. !                     write('.A')
  720.                        end
  721.                   else
  722.                       fatal(etree)
  723. --- 6264,6282 ----
  724.                       ch := chr(cvalof(tp^.taparm^.tnext));
  725.                       if (ch = bslash) or (ch = cite) then
  726.                           write(bslash);
  727. !                     write(ch, cite, ', -1')
  728.                       end
  729.                   else if tq = typnods[tstring] then
  730. !                     begin
  731. !                     eexpr(tp^.taparm^.tnext);
  732. !                     write(', -1')
  733. !                     end
  734. !                 else if tq^.tt = narray then
  735.                        begin
  736.                       eexpr(tp^.taparm^.tnext);
  737. !                     write('.A, sizeof(');
  738. !                     eexpr(tp^.taparm^.tnext);
  739. !                     write('.A)')
  740.                        end
  741.                   else
  742.                       fatal(etree)
  743. ***************
  744. *** 6487,6507 ****
  745.                           eexpr(tq);
  746.                           write(')')
  747.                           end
  748.                       else
  749.                           eexpr(tq);
  750.                       end
  751. !                 else if (tx = typnods[tstring]) or
  752. !                         (tx = typnods[tset]) then
  753.                       begin
  754. -                     (* cast literal to proper type *)
  755.                       write('*((');
  756.                       etypedef(tf^.tup^.tbind);
  757.                       write(' *)');
  758. !                     if tx = typnods[tset] then
  759.                           begin
  760. !                         dropset := true;
  761.                           eexpr(tq);
  762. !                         dropset := false
  763.                           end
  764.                       else
  765.                           eexpr(tq);
  766. --- 6535,6574 ----
  767.                           eexpr(tq);
  768.                           write(')')
  769.                           end
  770. +                     else if tf^.tup^.tt = nvarpar then
  771. +                         eaddr(tq)
  772.                       else
  773. +                         eexpr(tq)
  774. +                     end
  775. +                 else if tx = typnods[tset] then
  776. +                     begin
  777. +                     write('*((');
  778. +                     etypedef(tf^.tup^.tbind);
  779. +                     write(' *)');
  780. +                     dropset := true;
  781. +                     if align then
  782. +                         begin
  783. +                         usesal := true;
  784. +                         write('SETALIGN(');
  785.                           eexpr(tq);
  786. +                         write(')')
  787. +                         end
  788. +                     else
  789. +                         eexpr(tq);
  790. +                     dropset := false;
  791. +                     write(')')
  792.                       end
  793. !                 else if tx = typnods[tstring] then
  794.                       begin
  795.                       write('*((');
  796.                       etypedef(tf^.tup^.tbind);
  797.                       write(' *)');
  798. !                     if align then
  799.                           begin
  800. !                         usealig := true;
  801. !                         write('STRALIGN(');
  802.                           eexpr(tq);
  803. !                         write(')')
  804.                           end
  805.                       else
  806.                           eexpr(tq);
  807. ***************
  808. *** 6521,6528 ****
  809.                       eexpr(tq);
  810.                       (* add upper bound of actual value *)
  811.                       if tq^.tnext = nil then
  812. !                         write(', ',
  813. !                             crange(tx^.taindx):1)
  814.                       end
  815.                   else begin
  816.                       if tf^.tup^.tt = nvarpar then
  817. --- 6588,6600 ----
  818.                       eexpr(tq);
  819.                       (* add upper bound of actual value *)
  820.                       if tq^.tnext = nil then
  821. !                         begin
  822. !                         write(', (');
  823. !                         eexpr(tx^.taindx^.thi);
  824. !                         write(' - ');
  825. !                         eexpr(tx^.taindx^.tlo);
  826. !                         write(' + 1)')
  827. !                         end
  828.                       end
  829.                   else begin
  830.                       if tf^.tup^.tt = nvarpar then
  831. ***************
  832. *** 6930,6944 ****
  833.                   eexpr(tp^.texps);
  834.                   write('.buf')
  835.                   end
  836. !             else if doarrow = 0 then
  837.                   begin
  838. !                 write('*');
  839. !                 eexpr(tp^.texps)
  840. !                 end
  841. !             else begin
  842.                   eexpr(tp^.texps);
  843.                   write('->');
  844.                   donearr := true
  845.                    end
  846.               end;
  847.             nid:
  848. --- 7002,7018 ----
  849.                   eexpr(tp^.texps);
  850.                   write('.buf')
  851.                   end
  852. !             else if doarrow then
  853.                   begin
  854. !                 doarrow := false;
  855.                   eexpr(tp^.texps);
  856.                   write('->');
  857.                   donearr := true
  858. +                 end
  859. +             else begin
  860. +                 write('(*');
  861. +                 eexpr(tp^.texps);
  862. +                 write(')')
  863.                    end
  864.               end;
  865.             nid:
  866. ***************
  867. *** 6947,6966 ****
  868.                  var-parameter or as a procedure-parameter *)
  869.               tq := idup(tp);
  870.               if tq^.tt = nvarpar then
  871. !                 begin
  872. !                 if (doarrow = 0) or
  873. !                         (tq^.tattr = areference) then
  874.                       begin
  875. !                     write('(*');
  876.                       printid(tp^.tsym^.lid);
  877. !                     write(')')
  878.                       end
  879.                   else begin
  880.                       printid(tp^.tsym^.lid);
  881. !                     write('->');
  882. !                     donearr := true
  883.                        end
  884. -                 end
  885.               else if (tq^.tt = nconst) and conflag then
  886.                   write(cvalof(tp):1)
  887.               else if tq^.tt in [nparproc, nparfunc] then
  888. --- 7021,7038 ----
  889.                  var-parameter or as a procedure-parameter *)
  890.               tq := idup(tp);
  891.               if tq^.tt = nvarpar then
  892. !                 if doarrow then
  893.                       begin
  894. !                     doarrow := false;
  895.                       printid(tp^.tsym^.lid);
  896. !                     write('->');
  897. !                     donearr := true
  898.                       end
  899.                   else begin
  900. +                     write('(*');
  901.                       printid(tp^.tsym^.lid);
  902. !                     write(')')
  903.                        end
  904.               else if (tq^.tt = nconst) and conflag then
  905.                   write(cvalof(tp):1)
  906.               else if tq^.tt in [nparproc, nparfunc] then
  907. ***************
  908. *** 7107,7112 ****
  909. --- 7179,7206 ----
  910.               end
  911.       end;    (* econst *)
  912.   
  913. +     (*    Undefine constants.                    *)
  914. +     procedure edconst(tp : treeptr);
  915. + 
  916. +     var    sp    : symptr;
  917. + 
  918. +     begin
  919. +         while tp <> nil do
  920. +             begin
  921. +             sp := tp^.tidl^.tsym;
  922. +             if tp^.tbind^.tt <> nstring then
  923. +                 begin
  924. +                 (* all non-strings are emitted as
  925. +                    preprocessor # defines *)
  926. +                 write(undef);
  927. +                 printid(sp^.lid);
  928. +                 writeln
  929. +                 end;
  930. +             tp := tp^.tnext
  931. +             end
  932. +     end;    (* edconst *)
  933. + 
  934. + 
  935.       (*    Emit a typedef.                        *)
  936.       procedure etypedef;
  937.   
  938. ***************
  939. *** 7867,7876 ****
  940.                 ncase:
  941.                   begin
  942.                   indent;
  943. !                 write('switch (');
  944.                   increment;
  945.                   eexpr(tp^.tcasxp);
  946. !                 writeln(') {');
  947.                   decrement;
  948.                   echoise(tp^.tcaslst);
  949.                   indent;
  950. --- 7961,7970 ----
  951.                 ncase:
  952.                   begin
  953.                   indent;
  954. !                 write('switch ((int)(');
  955.                   increment;
  956.                   eexpr(tp^.tcasxp);
  957. !                 writeln(')) {');
  958.                   decrement;
  959.                   echoise(tp^.tcaslst);
  960.                   indent;
  961. ***************
  962. *** 8052,8058 ****
  963.               indent;
  964.               writeln('  case 0:');
  965.               indent;
  966. !             writeln(tab1, 'break');
  967.               tq := tp^.tsublab;
  968.               while tq <> nil do
  969.                   begin
  970. --- 8146,8152 ----
  971.               indent;
  972.               writeln('  case 0:');
  973.               indent;
  974. !             writeln(tab1, 'break;');
  975.               tq := tp^.tsublab;
  976.               while tq <> nil do
  977.                   begin
  978. ***************
  979. *** 8071,8077 ****
  980.               indent;
  981.               writeln('  default:');
  982.               indent;
  983. !             writeln(tab1, 'Caseerror(Line)');
  984.               indent;
  985.               writeln('}')
  986.               end
  987. --- 8165,8171 ----
  988.               indent;
  989.               writeln('  default:');
  990.               indent;
  991. !             writeln(tab1, 'Caseerror(Line);');
  992.               indent;
  993.               writeln('}')
  994.               end
  995. ***************
  996. *** 8198,8203 ****
  997. --- 8292,8298 ----
  998.                   writeln(';');
  999.                   end;
  1000.               decrement;
  1001. +             edconst(tp^.tsubconst);
  1002.               writeln('}');
  1003.           999:
  1004.               writeln;
  1005. ***************
  1006. *** 8337,8345 ****
  1007.               writeln(define, 'Putl(f, v) (f).eoln = v')
  1008.               end;
  1009.           if use(dreset) or use(drewrite) or use(dclose) then
  1010.               writeln(define, 'Finish(f) ((f).out && !(f).eoln) ? ',
  1011.                   '(Putchr(', nlchr, ', f), 0) : 0, ',
  1012. !                     'rewind((f).fp)');    (* LIB *)
  1013.           if use(dclose) then
  1014.               begin
  1015.               writeln(define, 'Close(f) (f).init = ',
  1016. --- 8432,8443 ----
  1017.               writeln(define, 'Putl(f, v) (f).eoln = v')
  1018.               end;
  1019.           if use(dreset) or use(drewrite) or use(dclose) then
  1020. +             begin
  1021.               writeln(define, 'Finish(f) ((f).out && !(f).eoln) ? ',
  1022.                   '(Putchr(', nlchr, ', f), 0) : 0, ',
  1023. !                     '!fseek((f).fp, 0L, 0)'); (* LIB *)
  1024. !             writeln(xtern, 'int', tab1, 'fseek();')    (* LIB *)
  1025. !             end;
  1026.           if use(dclose) then
  1027.               begin
  1028.               writeln(define, 'Close(f) (f).init = ',
  1029. ***************
  1030. *** 8359,8371 ****
  1031.               writeln(elsif);
  1032.               writeln(static, chartyp, tab1, 'Rmode[] = "r+";');
  1033.               writeln(endif);
  1034. !             writeln(define, 'Reset(f, n) (f).init = ',
  1035. !                 '(f).init ? rewind((f).fp) : ',    (* LIB *)
  1036. !                 '(((f).fp = Fopen(n, Rmode)), 1), ',
  1037.                       '(f).eof = (f).out = 0, Get(f)');
  1038. !             writeln(define, 'Resetx(f, n) (f).init = ',
  1039.                   '(f).init ? (Finish(f)) : ',
  1040. !                 '(((f).fp = Fopen(n, Rmode)), 1), ',
  1041.                       '(f).eof = (f).out = 0, Getx(f)');
  1042.               usefopn := true
  1043.               end;
  1044. --- 8457,8469 ----
  1045.               writeln(elsif);
  1046.               writeln(static, chartyp, tab1, 'Rmode[] = "r+";');
  1047.               writeln(endif);
  1048. !             writeln(define, 'Reset(f, n, l) (f).init = ',
  1049. !                 '(f).init ? !fseek((f).fp, 0L, 0) : ', (* LIB *)
  1050. !                 '(((f).fp = Fopen(n, l, Rmode)), 1), ',
  1051.                       '(f).eof = (f).out = 0, Get(f)');
  1052. !             writeln(define, 'Resetx(f, n, l) (f).init = ',
  1053.                   '(f).init ? (Finish(f)) : ',
  1054. !                 '(((f).fp = Fopen(n, l, Rmode)), 1), ',
  1055.                       '(f).eof = (f).out = 0, Getx(f)');
  1056.               usefopn := true
  1057.               end;
  1058. ***************
  1059. *** 8376,8388 ****
  1060.               writeln(elsif);
  1061.               writeln(static, chartyp, tab1, 'Wmode[] = "w+";');
  1062.               writeln(endif);
  1063. !             writeln(define, 'Rewrite(f, n) (f).init = ',
  1064. !                 '(f).init ? rewind((f).fp) : ',    (* LIB *)
  1065. !                 '(((f).fp = Fopen(n, Wmode)), 1), ',
  1066.                       '(f).out = (f).eof = 1');
  1067. !             writeln(define, 'Rewritex(f, n) (f).init = ',
  1068.                   '(f).init ? (Finish(f)) : ',
  1069. !                 '(((f).fp = Fopen(n, Wmode)), 1), ',
  1070.                       '(f).out = (f).eof = (f).eoln = 1');
  1071.               usefopn := true
  1072.               end;
  1073. --- 8474,8486 ----
  1074.               writeln(elsif);
  1075.               writeln(static, chartyp, tab1, 'Wmode[] = "w+";');
  1076.               writeln(endif);
  1077. !             writeln(define, 'Rewrite(f, n, l) (f).init = ',
  1078. !                 '(f).init ? !fseek((f).fp, 0L, 0) : ', (* LIB *)
  1079. !                 '(((f).fp = Fopen(n, l, Wmode)), 1), ',
  1080.                       '(f).out = (f).eof = 1');
  1081. !             writeln(define, 'Rewritex(f, n, l) (f).init = ',
  1082.                   '(f).init ? (Finish(f)) : ',
  1083. !                 '(((f).fp = Fopen(n, l, Wmode)), 1), ',
  1084.                       '(f).out = (f).eof = (f).eoln = 1');
  1085.               usefopn := true
  1086.               end;
  1087. ***************
  1088. *** 8389,8395 ****
  1089.           if usefopn then
  1090.               begin
  1091.               writeln('FILE    *Fopen();');
  1092. !             writeln(define, 'MAXFILENAME 256')
  1093.               end;
  1094.           if usecase or usejmps then
  1095.               begin
  1096. --- 8487,8495 ----
  1097.           if usefopn then
  1098.               begin
  1099.               writeln('FILE    *Fopen();');
  1100. !             writeln(ifndef, maxfilename);
  1101. !             writeln(define, maxfilename, ' ', (maxtoknlen+1):1);
  1102. !             writeln(endif)
  1103.               end;
  1104.           if usecase or usejmps then
  1105.               begin
  1106. ***************
  1107. *** 8443,8449 ****
  1108.               write(' (');
  1109.               printid(defnams[dboolean]^.lid);
  1110.               writeln(')1');
  1111. !             writeln(xtern, chartyp, tab1, '*Bools[];')
  1112.               end;
  1113.           capital(defnams[dinteger]);
  1114.           if use(dinteger) then
  1115. --- 8543,8549 ----
  1116.               write(' (');
  1117.               printid(defnams[dboolean]^.lid);
  1118.               writeln(')1');
  1119. !             writeln(chartyp, tab1, '*Bools[];')
  1120.               end;
  1121.           capital(defnams[dinteger]);
  1122.           if use(dinteger) then
  1123. ***************
  1124. *** 8519,8527 ****
  1125.               writeln(setptyp, tab1, 'Insmem(), Mksubr();');
  1126.               writeln(setptyp, tab1, 'Currset(), Inter();');
  1127.               writeln(static, setptyp, tab1, 'Tmpset;');
  1128. !             writeln(xtern, setptyp, tab1, 'Conset[];');
  1129.               writeln(voidtyp, tab1, 'Setncpy();')
  1130.               end;
  1131.           writeln(xtern, chartyp, ' *strncpy();');    (* LIB *)
  1132.           if use(dargc) or use(dargv) then
  1133.               begin
  1134. --- 8619,8640 ----
  1135.               writeln(setptyp, tab1, 'Insmem(), Mksubr();');
  1136.               writeln(setptyp, tab1, 'Currset(), Inter();');
  1137.               writeln(static, setptyp, tab1, 'Tmpset;');
  1138. !             writeln(setptyp, tab1, 'Conset[];');
  1139.               writeln(voidtyp, tab1, 'Setncpy();')
  1140.               end;
  1141. +         if align then                    (* CPU *)
  1142. +             begin
  1143. +             writeln(ifndef, 'SETALIGN');
  1144. +             writeln(define, 'SETALIGN(x) Alignset(x)');
  1145. +             writeln('struct Set { ', wordtype, tab1, 'S[',
  1146. +                     maxsetrange:1, '+1]; } *Alignset();');
  1147. +             writeln(endif);
  1148. +             writeln(ifndef, 'STRALIGN');
  1149. +             writeln(define, 'STRALIGN(x) Alignstr(x)');
  1150. +             writeln('struct String { char    A[',
  1151. +                     maxtoknlen:1, '+1]; } *Alignstr();');
  1152. +             writeln(endif)
  1153. +             end;
  1154.           writeln(xtern, chartyp, ' *strncpy();');    (* LIB *)
  1155.           if use(dargc) or use(dargv) then
  1156.               begin
  1157. ***************
  1158. *** 8577,8589 ****
  1159. --- 8690,8711 ----
  1160.                   writeln('main()');
  1161.                   writeln('{')
  1162.                    end;
  1163. +             if use(dinput) then
  1164. +                 begin
  1165. +                 writeln(ifdef, 'STDINIT');
  1166. +                 writeln(tab1, voidcast, '(Getx(input));');
  1167. +                 writeln(endif)
  1168. +                 end;
  1169.               increment;
  1170.               elabel(tp);
  1171.               estmt(tp^.tsubstmt);
  1172.               indent;
  1173.               writeln('exit(0);');
  1174. +             indent;
  1175. +             writeln('/', '* NOTREACHED *', '/');
  1176.               decrement;
  1177.               writeln('}');
  1178. +             edconst(tp^.tsubconst);
  1179.               writeln('/', '*');
  1180.               writeln('**    End of program code');
  1181.               writeln('*', '/')
  1182. ***************
  1183. *** 8716,8725 ****
  1184.       conflag := false;
  1185.       setused := false;
  1186.       dropset := false;
  1187. !     doarrow := 0;
  1188.       eprogram(top);
  1189.       if usebool then
  1190. !         writeln(chartyp, tab1, '*Bools[] = { "false", "true" };');
  1191.       if usescan then
  1192.           begin
  1193.           writeln;
  1194. --- 8838,8848 ----
  1195.       conflag := false;
  1196.       setused := false;
  1197.       dropset := false;
  1198. !     doarrow := false;
  1199. !     donearr := false;
  1200.       eprogram(top);
  1201.       if usebool then
  1202. !         writeln(static, chartyp, tab1, '*Bools[] = { "false", "true" };');
  1203.       if usescan then
  1204.           begin
  1205.           writeln;
  1206. ***************
  1207. *** 8749,8770 ****
  1208.           begin
  1209.           writeln;
  1210.           writeln(static, 'FILE *');
  1211. !         writeln('Fopen(n, m)');
  1212.           writeln(chartyp, tab1, '*n, *m;');
  1213.           writeln('{');
  1214.           writeln(tab1, 'FILE', tab2, '*f;');
  1215.           writeln(tab1, registr, chartyp, tab1, '*s;');
  1216.           writeln(tab1, static, chartyp, tab1, 'ch = ',
  1217.                           quote, 'A', quote, ';');
  1218. !         writeln(tab1, static, chartyp, tab1, 'tmp[MAXFILENAME];');
  1219. !         writeln(tab1, xtern , inttyp, tab1, 'unlink();'); (* OS *)
  1220.           writeln;
  1221.           writeln(tab1, 'if (n == NULL)');
  1222.           writeln(tab2, 'sprintf(tmp, ', tmpfilename, 'ch++);');
  1223.           writeln(tab1, 'else {');
  1224.           writeln(tab2, 'strncpy(tmp, n, sizeof(tmp));');
  1225.           writeln(tab2, 'for (s = &tmp[sizeof(tmp)-1]; *s == ',
  1226. !             spchr, ' || *s == ', nulchr, '; )');
  1227.           writeln(tab3, '*s-- = ', nulchr, ';');
  1228.           writeln(tab2, 'if (tmp[sizeof(tmp)-1]) {');
  1229.           writeln(tab3, voidcast, 'fprintf(stderr, "Too long filename ',
  1230. --- 8872,8897 ----
  1231.           begin
  1232.           writeln;
  1233.           writeln(static, 'FILE *');
  1234. !         writeln('Fopen(n, l, m)');
  1235.           writeln(chartyp, tab1, '*n, *m;');
  1236. +         writeln(inttyp, tab1, 'l;');
  1237.           writeln('{');
  1238.           writeln(tab1, 'FILE', tab2, '*f;');
  1239.           writeln(tab1, registr, chartyp, tab1, '*s;');
  1240.           writeln(tab1, static, chartyp, tab1, 'ch = ',
  1241.                           quote, 'A', quote, ';');
  1242. !         writeln(tab1, static, chartyp, tab1, 'tmp[', maxfilename, '];');
  1243. !         writeln(tab1, xtern , inttyp, tab1, 'unlink(),'); (* OS *)
  1244. !         writeln(tab3, 'strlen();'); (* OS *)
  1245.           writeln;
  1246.           writeln(tab1, 'if (n == NULL)');
  1247.           writeln(tab2, 'sprintf(tmp, ', tmpfilename, 'ch++);');
  1248.           writeln(tab1, 'else {');
  1249. +         writeln(tab2, 'if (l < 0)');
  1250. +         writeln(tab3, 'l = strlen(n);');
  1251.           writeln(tab2, 'strncpy(tmp, n, sizeof(tmp));');
  1252.           writeln(tab2, 'for (s = &tmp[sizeof(tmp)-1]; *s == ',
  1253. !             spchr, ' || *s == ', nulchr, ' || s - tmp > l; )');
  1254.           writeln(tab3, '*s-- = ', nulchr, ';');
  1255.           writeln(tab2, 'if (tmp[sizeof(tmp)-1]) {');
  1256.           writeln(tab3, voidcast, 'fprintf(stderr, "Too long filename ',
  1257. ***************
  1258. *** 8782,8788 ****
  1259.           writeln(tab2, 'unlink(tmp);');    (* OS *)
  1260.           writeln(tab1, 'return (f);');
  1261.           writeln('}');
  1262. -         writeln(xtern, inttyp, tab1, 'rewind();')
  1263.           end;
  1264.       if setcnt > 0 then
  1265.           econset(setlst, setcnt);
  1266. --- 8909,8914 ----
  1267. ***************
  1268. *** 9098,9106 ****
  1269.           writeln(tab2, '*S1++ = 0;');
  1270.           writeln('}')
  1271.           end;
  1272. !     if usecase then
  1273.           begin
  1274.           writeln;
  1275.           writeln(static, voidtyp);
  1276.           writeln('Caseerror(n)');
  1277.           writeln(tab1, inttyp, tab1, 'n;');
  1278. --- 9224,9263 ----
  1279.           writeln(tab2, '*S1++ = 0;');
  1280.           writeln('}')
  1281.           end;
  1282. !     if usesal then
  1283.           begin
  1284.           writeln;
  1285. +         writeln(static, 'struct Set *');
  1286. +         writeln('Alignset(Sp)');
  1287. +         writeln(tab1, registr, wordtype, tab1, '*Sp;');
  1288. +         writeln('{');
  1289. +         writeln(tab1, static, 'struct Set', tab1, 'tmp;');
  1290. +         writeln(tab1, registr, wordtype, tab1, '*tp = tmp.S;');
  1291. +         writeln(tab1, registr, inttyp, tab2, 'i = *Sp;');
  1292. +         writeln;
  1293. +         writeln(tab1, 'while (i-- >= 0)');
  1294. +         writeln(tab2, '*tp++ = *Sp++;');
  1295. +         writeln(tab1, 'return (&tmp);');
  1296. +         writeln('}')
  1297. +         end;
  1298. +     if usealig then
  1299. +         begin
  1300. +         writeln;
  1301. +         writeln(static, 'struct String *');
  1302. +         writeln('Alignstr(Cp)');
  1303. +         writeln(tab1, registr, chartyp, tab1, '*Cp;');
  1304. +         writeln('{');
  1305. +         writeln(tab1, static, 'struct String', tab1, 'tmp;');
  1306. +         writeln(tab1, registr, chartyp, tab1, '*sp = tmp.A;');
  1307. +         writeln;
  1308. +         writeln(tab1, 'while (*sp++ = *Cp++)');
  1309. +         writeln(tab2, ';');
  1310. +         writeln(tab1, 'return (&tmp);');
  1311. +         writeln('}')
  1312. +         end;
  1313. +     if usecase or usejmps then
  1314. +         begin
  1315. +         writeln;
  1316.           writeln(static, voidtyp);
  1317.           writeln('Caseerror(n)');
  1318.           writeln(tab1, inttyp, tab1, 'n;');
  1319. ***************
  1320. *** 9108,9113 ****
  1321. --- 9265,9271 ----
  1322.           writeln(tab1, voidcast,
  1323.               'fprintf(stderr, "Missing case limb: line %d\n", n);');
  1324.           writeln(tab1, 'exit(1);');
  1325. +         writeln(tab1, '/', '* NOTREACHED *', '/');
  1326.           writeln('}')
  1327.           end;
  1328.       if usemax then
  1329. ***************
  1330. *** 9153,9158 ****
  1331. --- 9311,9318 ----
  1332.       t    : pretyps;
  1333.       d    : predefs;
  1334.   
  1335. +     hx    : packed array [ 1 .. 16 ] of char;
  1336. + 
  1337.       (*    Define names in ctable.                    *)
  1338.       procedure defname(cn : cnames; str : keyword);
  1339.   
  1340. ***************
  1341. *** 9328,9339 ****
  1342.   begin    (* initialize *)
  1343.       lineno := 1;
  1344.       colno := 0;
  1345.   
  1346.       initstrstore;
  1347.   
  1348.       setlst := nil;
  1349.       setcnt := 0;
  1350. !     hexdig := '0123456789ABCDEF';
  1351.   
  1352.       symtab := nil;
  1353.       statlvl := 0;
  1354. --- 9488,9501 ----
  1355.   begin    (* initialize *)
  1356.       lineno := 1;
  1357.       colno := 0;
  1358. +     pushed := false;
  1359.   
  1360.       initstrstore;
  1361.   
  1362.       setlst := nil;
  1363.       setcnt := 0;
  1364. !     hx := '0123456789ABCDEF';
  1365. !     unpack(hx, hexdig, 0);
  1366.   
  1367.       symtab := nil;
  1368.       statlvl := 0;
  1369. ***************
  1370. *** 9366,9371 ****
  1371. --- 9528,9535 ----
  1372.   
  1373.       usecomp := false;
  1374.       usemax    := false;
  1375. +     usealig    := false;
  1376. +     usesal    := false;
  1377.   
  1378.       for s := 0 to hashmax do
  1379.           idtab[s] := nil;
  1380. ***************
  1381. *** 9541,9546 ****
  1382. --- 9705,9713 ----
  1383.       defname(cungetc,    'ungetc    ');    (* LIB *)
  1384.       defname(cunion,        'union     ');
  1385.       defname(cunlink,    'unlink    ');    (* OS *)
  1386. +     defname(cfseek,        'fseek     ');    (* LIB *)
  1387. +     defname(cgetchar,    'getchar   ');    (* LIB *)
  1388. +     defname(cputchar,    'putchar   ');    (* LIB *)
  1389.       defname(cunsigned,    'unsigned  ');
  1390.       defname(cwrite,        'write     ');    (* OS *)
  1391.   
  1392. ***************
  1393. *** 9613,9619 ****
  1394.              describing type, fill in constant identifying type *)
  1395.           case t of
  1396.             tboolean:
  1397. !             typnods[t] := deftab[dboolean]; (* scalar type *)
  1398.             tchar:
  1399.               typnods[t] := deftab[dchar]^.tbind;
  1400.             tinteger:
  1401. --- 9780,9786 ----
  1402.              describing type, fill in constant identifying type *)
  1403.           case t of
  1404.             tboolean:
  1405. !             typnods[t] := deftab[dboolean]^.tbind;
  1406.             tchar:
  1407.               typnods[t] := deftab[dchar]^.tbind;
  1408.             tinteger:
  1409. SHAR_EOF
  1410. fi # end of overwriting check
  1411. #    End of shell archive
  1412. exit 0
  1413.  
  1414.  
  1415.